home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Python 1.3.3 / Python 133 SRC / Mac / Modules / res / Resmodule.c < prev    next >
Text File  |  1996-04-12  |  32KB  |  1,397 lines
  1.  
  2. /* =========================== Module Res =========================== */
  3.  
  4. #include "Python.h"
  5.  
  6.  
  7.  
  8. #define SystemSevenOrLater 1
  9.  
  10. #include "macglue.h"
  11. #include <Memory.h>
  12. #include <Dialogs.h>
  13. #include <Menus.h>
  14. #include <Controls.h>
  15.  
  16. extern PyObject *ResObj_New(Handle);
  17. extern int ResObj_Convert(PyObject *, Handle *);
  18. extern PyObject *OptResObj_New(Handle);
  19. extern int OptResObj_Convert(PyObject *, Handle *);
  20.  
  21. extern PyObject *WinObj_New(WindowPtr);
  22. extern int WinObj_Convert(PyObject *, WindowPtr *);
  23. extern PyTypeObject Window_Type;
  24. #define WinObj_Check(x) ((x)->ob_type == &Window_Type)
  25.  
  26. extern PyObject *DlgObj_New(DialogPtr);
  27. extern int DlgObj_Convert(PyObject *, DialogPtr *);
  28. extern PyTypeObject Dialog_Type;
  29. #define DlgObj_Check(x) ((x)->ob_type == &Dialog_Type)
  30.  
  31. extern PyObject *MenuObj_New(MenuHandle);
  32. extern int MenuObj_Convert(PyObject *, MenuHandle *);
  33.  
  34. extern PyObject *CtlObj_New(ControlHandle);
  35. extern int CtlObj_Convert(PyObject *, ControlHandle *);
  36.  
  37. extern PyObject *GrafObj_New(GrafPtr);
  38. extern int GrafObj_Convert(PyObject *, GrafPtr *);
  39.  
  40. extern PyObject *BMObj_New(BitMapPtr);
  41. extern int BMObj_Convert(PyObject *, BitMapPtr *);
  42.  
  43. extern PyObject *PMObj_New(PixMapHandle);
  44. extern int PMObj_Convert(PyObject *, PixMapHandle *);
  45.  
  46. extern PyObject *WinObj_WhichWindow(WindowPtr);
  47.  
  48. #include <Resources.h>
  49.  
  50. #define resNotFound -192 /* Can't include <Errors.h> because of Python's "errors.h" */
  51.  
  52. static PyObject *Res_Error;
  53.  
  54. /* ---------------------- Object type Resource ---------------------- */
  55.  
  56. PyTypeObject Resource_Type;
  57.  
  58. #define ResObj_Check(x) ((x)->ob_type == &Resource_Type)
  59.  
  60. typedef struct ResourceObject {
  61.     PyObject_HEAD
  62.     Handle ob_itself;
  63. } ResourceObject;
  64.  
  65. PyObject *ResObj_New(itself)
  66.     Handle itself;
  67. {
  68.     ResourceObject *it;
  69.     if (itself == NULL) return PyMac_Error(resNotFound);
  70.     it = PyObject_NEW(ResourceObject, &Resource_Type);
  71.     if (it == NULL) return NULL;
  72.     it->ob_itself = itself;
  73.     return (PyObject *)it;
  74. }
  75. ResObj_Convert(v, p_itself)
  76.     PyObject *v;
  77.     Handle *p_itself;
  78. {
  79.     if (!ResObj_Check(v))
  80.     {
  81.         PyErr_SetString(PyExc_TypeError, "Resource required");
  82.         return 0;
  83.     }
  84.     *p_itself = ((ResourceObject *)v)->ob_itself;
  85.     return 1;
  86. }
  87.  
  88. static void ResObj_dealloc(self)
  89.     ResourceObject *self;
  90. {
  91.     /* Cleanup of self->ob_itself goes here */
  92.     PyMem_DEL(self);
  93. }
  94.  
  95. static PyObject *ResObj_HomeResFile(_self, _args)
  96.     ResourceObject *_self;
  97.     PyObject *_args;
  98. {
  99.     PyObject *_res = NULL;
  100.     short _rv;
  101.     if (!PyArg_ParseTuple(_args, ""))
  102.         return NULL;
  103.     _rv = HomeResFile(_self->ob_itself);
  104.     {
  105.         OSErr _err = ResError();
  106.         if (_err != noErr) return PyMac_Error(_err);
  107.     }
  108.     _res = Py_BuildValue("h",
  109.                          _rv);
  110.     return _res;
  111. }
  112.  
  113. static PyObject *ResObj_LoadResource(_self, _args)
  114.     ResourceObject *_self;
  115.     PyObject *_args;
  116. {
  117.     PyObject *_res = NULL;
  118.     if (!PyArg_ParseTuple(_args, ""))
  119.         return NULL;
  120.     LoadResource(_self->ob_itself);
  121.     {
  122.         OSErr _err = ResError();
  123.         if (_err != noErr) return PyMac_Error(_err);
  124.     }
  125.     Py_INCREF(Py_None);
  126.     _res = Py_None;
  127.     return _res;
  128. }
  129.  
  130. static PyObject *ResObj_ReleaseResource(_self, _args)
  131.     ResourceObject *_self;
  132.     PyObject *_args;
  133. {
  134.     PyObject *_res = NULL;
  135.     if (!PyArg_ParseTuple(_args, ""))
  136.         return NULL;
  137.     ReleaseResource(_self->ob_itself);
  138.     {
  139.         OSErr _err = ResError();
  140.         if (_err != noErr) return PyMac_Error(_err);
  141.     }
  142.     Py_INCREF(Py_None);
  143.     _res = Py_None;
  144.     return _res;
  145. }
  146.  
  147. static PyObject *ResObj_DetachResource(_self, _args)
  148.     ResourceObject *_self;
  149.     PyObject *_args;
  150. {
  151.     PyObject *_res = NULL;
  152.     if (!PyArg_ParseTuple(_args, ""))
  153.         return NULL;
  154.     DetachResource(_self->ob_itself);
  155.     {
  156.         OSErr _err = ResError();
  157.         if (_err != noErr) return PyMac_Error(_err);
  158.     }
  159.     Py_INCREF(Py_None);
  160.     _res = Py_None;
  161.     return _res;
  162. }
  163.  
  164. static PyObject *ResObj_GetResAttrs(_self, _args)
  165.     ResourceObject *_self;
  166.     PyObject *_args;
  167. {
  168.     PyObject *_res = NULL;
  169.     short _rv;
  170.     if (!PyArg_ParseTuple(_args, ""))
  171.         return NULL;
  172.     _rv = GetResAttrs(_self->ob_itself);
  173.     {
  174.         OSErr _err = ResError();
  175.         if (_err != noErr) return PyMac_Error(_err);
  176.     }
  177.     _res = Py_BuildValue("h",
  178.                          _rv);
  179.     return _res;
  180. }
  181.  
  182. static PyObject *ResObj_GetResInfo(_self, _args)
  183.     ResourceObject *_self;
  184.     PyObject *_args;
  185. {
  186.     PyObject *_res = NULL;
  187.     short theID;
  188.     ResType theType;
  189.     Str255 name;
  190.     if (!PyArg_ParseTuple(_args, ""))
  191.         return NULL;
  192.     GetResInfo(_self->ob_itself,
  193.                &theID,
  194.                &theType,
  195.                name);
  196.     {
  197.         OSErr _err = ResError();
  198.         if (_err != noErr) return PyMac_Error(_err);
  199.     }
  200.     _res = Py_BuildValue("hO&O&",
  201.                          theID,
  202.                          PyMac_BuildOSType, theType,
  203.                          PyMac_BuildStr255, name);
  204.     return _res;
  205. }
  206.  
  207. static PyObject *ResObj_SetResInfo(_self, _args)
  208.     ResourceObject *_self;
  209.     PyObject *_args;
  210. {
  211.     PyObject *_res = NULL;
  212.     short theID;
  213.     Str255 name;
  214.     if (!PyArg_ParseTuple(_args, "hO&",
  215.                           &theID,
  216.                           PyMac_GetStr255, name))
  217.         return NULL;
  218.     SetResInfo(_self->ob_itself,
  219.                theID,
  220.                name);
  221.     {
  222.         OSErr _err = ResError();
  223.         if (_err != noErr) return PyMac_Error(_err);
  224.     }
  225.     Py_INCREF(Py_None);
  226.     _res = Py_None;
  227.     return _res;
  228. }
  229.  
  230. static PyObject *ResObj_AddResource(_self, _args)
  231.     ResourceObject *_self;
  232.     PyObject *_args;
  233. {
  234.     PyObject *_res = NULL;
  235.     ResType theType;
  236.     short theID;
  237.     Str255 name;
  238.     if (!PyArg_ParseTuple(_args, "O&hO&",
  239.                           PyMac_GetOSType, &theType,
  240.                           &theID,
  241.                           PyMac_GetStr255, name))
  242.         return NULL;
  243.     AddResource(_self->ob_itself,
  244.                 theType,
  245.                 theID,
  246.                 name);
  247.     {
  248.         OSErr _err = ResError();
  249.         if (_err != noErr) return PyMac_Error(_err);
  250.     }
  251.     Py_INCREF(Py_None);
  252.     _res = Py_None;
  253.     return _res;
  254. }
  255.  
  256. static PyObject *ResObj_GetResourceSizeOnDisk(_self, _args)
  257.     ResourceObject *_self;
  258.     PyObject *_args;
  259. {
  260.     PyObject *_res = NULL;
  261.     long _rv;
  262.     if (!PyArg_ParseTuple(_args, ""))
  263.         return NULL;
  264.     _rv = GetResourceSizeOnDisk(_self->ob_itself);
  265.     {
  266.         OSErr _err = ResError();
  267.         if (_err != noErr) return PyMac_Error(_err);
  268.     }
  269.     _res = Py_BuildValue("l",
  270.                          _rv);
  271.     return _res;
  272. }
  273.  
  274. static PyObject *ResObj_GetMaxResourceSize(_self, _args)
  275.     ResourceObject *_self;
  276.     PyObject *_args;
  277. {
  278.     PyObject *_res = NULL;
  279.     long _rv;
  280.     if (!PyArg_ParseTuple(_args, ""))
  281.         return NULL;
  282.     _rv = GetMaxResourceSize(_self->ob_itself);
  283.     {
  284.         OSErr _err = ResError();
  285.         if (_err != noErr) return PyMac_Error(_err);
  286.     }
  287.     _res = Py_BuildValue("l",
  288.                          _rv);
  289.     return _res;
  290. }
  291.  
  292. static PyObject *ResObj_RsrcMapEntry(_self, _args)
  293.     ResourceObject *_self;
  294.     PyObject *_args;
  295. {
  296.     PyObject *_res = NULL;
  297.     long _rv;
  298.     if (!PyArg_ParseTuple(_args, ""))
  299.         return NULL;
  300.     _rv = RsrcMapEntry(_self->ob_itself);
  301.     {
  302.         OSErr _err = ResError();
  303.         if (_err != noErr) return PyMac_Error(_err);
  304.     }
  305.     _res = Py_BuildValue("l",
  306.                          _rv);
  307.     return _res;
  308. }
  309.  
  310. static PyObject *ResObj_SetResAttrs(_self, _args)
  311.     ResourceObject *_self;
  312.     PyObject *_args;
  313. {
  314.     PyObject *_res = NULL;
  315.     short attrs;
  316.     if (!PyArg_ParseTuple(_args, "h",
  317.                           &attrs))
  318.         return NULL;
  319.     SetResAttrs(_self->ob_itself,
  320.                 attrs);
  321.     {
  322.         OSErr _err = ResError();
  323.         if (_err != noErr) return PyMac_Error(_err);
  324.     }
  325.     Py_INCREF(Py_None);
  326.     _res = Py_None;
  327.     return _res;
  328. }
  329.  
  330. static PyObject *ResObj_ChangedResource(_self, _args)
  331.     ResourceObject *_self;
  332.     PyObject *_args;
  333. {
  334.     PyObject *_res = NULL;
  335.     if (!PyArg_ParseTuple(_args, ""))
  336.         return NULL;
  337.     ChangedResource(_self->ob_itself);
  338.     {
  339.         OSErr _err = ResError();
  340.         if (_err != noErr) return PyMac_Error(_err);
  341.     }
  342.     Py_INCREF(Py_None);
  343.     _res = Py_None;
  344.     return _res;
  345. }
  346.  
  347. static PyObject *ResObj_RemoveResource(_self, _args)
  348.     ResourceObject *_self;
  349.     PyObject *_args;
  350. {
  351.     PyObject *_res = NULL;
  352.     if (!PyArg_ParseTuple(_args, ""))
  353.         return NULL;
  354.     RemoveResource(_self->ob_itself);
  355.     {
  356.         OSErr _err = ResError();
  357.         if (_err != noErr) return PyMac_Error(_err);
  358.     }
  359.     Py_INCREF(Py_None);
  360.     _res = Py_None;
  361.     return _res;
  362. }
  363.  
  364. static PyObject *ResObj_WriteResource(_self, _args)
  365.     ResourceObject *_self;
  366.     PyObject *_args;
  367. {
  368.     PyObject *_res = NULL;
  369.     if (!PyArg_ParseTuple(_args, ""))
  370.         return NULL;
  371.     WriteResource(_self->ob_itself);
  372.     {
  373.         OSErr _err = ResError();
  374.         if (_err != noErr) return PyMac_Error(_err);
  375.     }
  376.     Py_INCREF(Py_None);
  377.     _res = Py_None;
  378.     return _res;
  379. }
  380.  
  381. static PyObject *ResObj_SetResourceSize(_self, _args)
  382.     ResourceObject *_self;
  383.     PyObject *_args;
  384. {
  385.     PyObject *_res = NULL;
  386.     long newSize;
  387.     if (!PyArg_ParseTuple(_args, "l",
  388.                           &newSize))
  389.         return NULL;
  390.     SetResourceSize(_self->ob_itself,
  391.                     newSize);
  392.     {
  393.         OSErr _err = ResError();
  394.         if (_err != noErr) return PyMac_Error(_err);
  395.     }
  396.     Py_INCREF(Py_None);
  397.     _res = Py_None;
  398.     return _res;
  399. }
  400.  
  401. static PyObject *ResObj_GetNextFOND(_self, _args)
  402.     ResourceObject *_self;
  403.     PyObject *_args;
  404. {
  405.     PyObject *_res = NULL;
  406.     Handle _rv;
  407.     if (!PyArg_ParseTuple(_args, ""))
  408.         return NULL;
  409.     _rv = GetNextFOND(_self->ob_itself);
  410.     {
  411.         OSErr _err = ResError();
  412.         if (_err != noErr) return PyMac_Error(_err);
  413.     }
  414.     _res = Py_BuildValue("O&",
  415.                          ResObj_New, _rv);
  416.     return _res;
  417. }
  418.  
  419. static PyObject *ResObj_as_Control(_self, _args)
  420.     ResourceObject *_self;
  421.     PyObject *_args;
  422. {
  423.     PyObject *_res = NULL;
  424.  
  425.     return CtlObj_New((ControlHandle)_self->ob_itself);
  426.  
  427. }
  428.  
  429. static PyObject *ResObj_as_Menu(_self, _args)
  430.     ResourceObject *_self;
  431.     PyObject *_args;
  432. {
  433.     PyObject *_res = NULL;
  434.  
  435.     return MenuObj_New((MenuHandle)_self->ob_itself);
  436.  
  437. }
  438.  
  439. static PyMethodDef ResObj_methods[] = {
  440.     {"HomeResFile", (PyCFunction)ResObj_HomeResFile, 1,
  441.      "() -> (short _rv)"},
  442.     {"LoadResource", (PyCFunction)ResObj_LoadResource, 1,
  443.      "() -> None"},
  444.     {"ReleaseResource", (PyCFunction)ResObj_ReleaseResource, 1,
  445.      "() -> None"},
  446.     {"DetachResource", (PyCFunction)ResObj_DetachResource, 1,
  447.      "() -> None"},
  448.     {"GetResAttrs", (PyCFunction)ResObj_GetResAttrs, 1,
  449.      "() -> (short _rv)"},
  450.     {"GetResInfo", (PyCFunction)ResObj_GetResInfo, 1,
  451.      "() -> (short theID, ResType theType, Str255 name)"},
  452.     {"SetResInfo", (PyCFunction)ResObj_SetResInfo, 1,
  453.      "(short theID, Str255 name) -> None"},
  454.     {"AddResource", (PyCFunction)ResObj_AddResource, 1,
  455.      "(ResType theType, short theID, Str255 name) -> None"},
  456.     {"GetResourceSizeOnDisk", (PyCFunction)ResObj_GetResourceSizeOnDisk, 1,
  457.      "() -> (long _rv)"},
  458.     {"GetMaxResourceSize", (PyCFunction)ResObj_GetMaxResourceSize, 1,
  459.      "() -> (long _rv)"},
  460.     {"RsrcMapEntry", (PyCFunction)ResObj_RsrcMapEntry, 1,
  461.      "() -> (long _rv)"},
  462.     {"SetResAttrs", (PyCFunction)ResObj_SetResAttrs, 1,
  463.      "(short attrs) -> None"},
  464.     {"ChangedResource", (PyCFunction)ResObj_ChangedResource, 1,
  465.      "() -> None"},
  466.     {"RemoveResource", (PyCFunction)ResObj_RemoveResource, 1,
  467.      "() -> None"},
  468.     {"WriteResource", (PyCFunction)ResObj_WriteResource, 1,
  469.      "() -> None"},
  470.     {"SetResourceSize", (PyCFunction)ResObj_SetResourceSize, 1,
  471.      "(long newSize) -> None"},
  472.     {"GetNextFOND", (PyCFunction)ResObj_GetNextFOND, 1,
  473.      "() -> (Handle _rv)"},
  474.     {"as_Control", (PyCFunction)ResObj_as_Control, 1,
  475.      "Return this resource/handle as a Control"},
  476.     {"as_Menu", (PyCFunction)ResObj_as_Menu, 1,
  477.      "Return this resource/handle as a Menu"},
  478.     {NULL, NULL, 0}
  479. };
  480.  
  481. PyMethodChain ResObj_chain = { ResObj_methods, NULL };
  482.  
  483. static PyObject *ResObj_getattr(self, name)
  484.     ResourceObject *self;
  485.     char *name;
  486. {
  487.  
  488.     if (strcmp(name, "size") == 0)
  489.         return PyInt_FromLong(GetHandleSize(self->ob_itself));
  490.     if (strcmp(name, "data") == 0) {
  491.         PyObject *res;
  492.         char state;
  493.         state = HGetState(self->ob_itself);
  494.         HLock(self->ob_itself);
  495.         res = PyString_FromStringAndSize(
  496.             *self->ob_itself,
  497.             GetHandleSize(self->ob_itself));
  498.         HUnlock(self->ob_itself);
  499.         HSetState(self->ob_itself, state);
  500.         return res;
  501.     }
  502.     if (strcmp(name, "__members__") == 0)
  503.         return Py_BuildValue("[ss]", "data", "size");
  504.  
  505.     return Py_FindMethodInChain(&ResObj_chain, (PyObject *)self, name);
  506. }
  507.  
  508. static int
  509. ResObj_setattr(self, name, value)
  510.     ResourceObject *self;
  511.     char *name;
  512.     PyObject *value;
  513. {
  514.     char *data;
  515.     long size;
  516.     
  517.     if (strcmp(name, "data") != 0 || value == NULL )
  518.         return -1;
  519.     if ( !PyString_Check(value) )
  520.         return -1;
  521.     size = PyString_Size(value);
  522.     data = PyString_AsString(value);
  523.     /* XXXX Do I need the GetState/SetState calls? */
  524.     SetHandleSize(self->ob_itself, size);
  525.     if ( MemError())
  526.         return -1;
  527.     HLock(self->ob_itself);
  528.     memcpy((char *)*self->ob_itself, data, size);
  529.     HUnlock(self->ob_itself);
  530.     /* XXXX Should I do the Changed call immedeately? */
  531.     return 0;
  532. }
  533.  
  534.  
  535. PyTypeObject Resource_Type = {
  536.     PyObject_HEAD_INIT(&PyType_Type)
  537.     0, /*ob_size*/
  538.     "Resource", /*tp_name*/
  539.     sizeof(ResourceObject), /*tp_basicsize*/
  540.     0, /*tp_itemsize*/
  541.     /* methods */
  542.     (destructor) ResObj_dealloc, /*tp_dealloc*/
  543.     0, /*tp_print*/
  544.     (getattrfunc) ResObj_getattr, /*tp_getattr*/
  545.     (setattrfunc) ResObj_setattr, /*tp_setattr*/
  546. };
  547.  
  548. /* -------------------- End object type Resource -------------------- */
  549.  
  550.  
  551. static PyObject *Res_InitResources(_self, _args)
  552.     PyObject *_self;
  553.     PyObject *_args;
  554. {
  555.     PyObject *_res = NULL;
  556.     short _rv;
  557.     if (!PyArg_ParseTuple(_args, ""))
  558.         return NULL;
  559.     _rv = InitResources();
  560.     {
  561.         OSErr _err = ResError();
  562.         if (_err != noErr) return PyMac_Error(_err);
  563.     }
  564.     _res = Py_BuildValue("h",
  565.                          _rv);
  566.     return _res;
  567. }
  568.  
  569. static PyObject *Res_RsrcZoneInit(_self, _args)
  570.     PyObject *_self;
  571.     PyObject *_args;
  572. {
  573.     PyObject *_res = NULL;
  574.     if (!PyArg_ParseTuple(_args, ""))
  575.         return NULL;
  576.     RsrcZoneInit();
  577.     {
  578.         OSErr _err = ResError();
  579.         if (_err != noErr) return PyMac_Error(_err);
  580.     }
  581.     Py_INCREF(Py_None);
  582.     _res = Py_None;
  583.     return _res;
  584. }
  585.  
  586. static PyObject *Res_CloseResFile(_self, _args)
  587.     PyObject *_self;
  588.     PyObject *_args;
  589. {
  590.     PyObject *_res = NULL;
  591.     short refNum;
  592.     if (!PyArg_ParseTuple(_args, "h",
  593.                           &refNum))
  594.         return NULL;
  595.     CloseResFile(refNum);
  596.     {
  597.         OSErr _err = ResError();
  598.         if (_err != noErr) return PyMac_Error(_err);
  599.     }
  600.     Py_INCREF(Py_None);
  601.     _res = Py_None;
  602.     return _res;
  603. }
  604.  
  605. static PyObject *Res_ResError(_self, _args)
  606.     PyObject *_self;
  607.     PyObject *_args;
  608. {
  609.     PyObject *_res = NULL;
  610.     short _rv;
  611.     if (!PyArg_ParseTuple(_args, ""))
  612.         return NULL;
  613.     _rv = ResError();
  614.     {
  615.         OSErr _err = ResError();
  616.         if (_err != noErr) return PyMac_Error(_err);
  617.     }
  618.     _res = Py_BuildValue("h",
  619.                          _rv);
  620.     return _res;
  621. }
  622.  
  623. static PyObject *Res_CurResFile(_self, _args)
  624.     PyObject *_self;
  625.     PyObject *_args;
  626. {
  627.     PyObject *_res = NULL;
  628.     short _rv;
  629.     if (!PyArg_ParseTuple(_args, ""))
  630.         return NULL;
  631.     _rv = CurResFile();
  632.     {
  633.         OSErr _err = ResError();
  634.         if (_err != noErr) return PyMac_Error(_err);
  635.     }
  636.     _res = Py_BuildValue("h",
  637.                          _rv);
  638.     return _res;
  639. }
  640.  
  641. static PyObject *Res_CreateResFile(_self, _args)
  642.     PyObject *_self;
  643.     PyObject *_args;
  644. {
  645.     PyObject *_res = NULL;
  646.     Str255 fileName;
  647.     if (!PyArg_ParseTuple(_args, "O&",
  648.                           PyMac_GetStr255, fileName))
  649.         return NULL;
  650.     CreateResFile(fileName);
  651.     {
  652.         OSErr _err = ResError();
  653.         if (_err != noErr) return PyMac_Error(_err);
  654.     }
  655.     Py_INCREF(Py_None);
  656.     _res = Py_None;
  657.     return _res;
  658. }
  659.  
  660. static PyObject *Res_OpenResFile(_self, _args)
  661.     PyObject *_self;
  662.     PyObject *_args;
  663. {
  664.     PyObject *_res = NULL;
  665.     short _rv;
  666.     Str255 fileName;
  667.     if (!PyArg_ParseTuple(_args, "O&",
  668.                           PyMac_GetStr255, fileName))
  669.         return NULL;
  670.     _rv = OpenResFile(fileName);
  671.     {
  672.         OSErr _err = ResError();
  673.         if (_err != noErr) return PyMac_Error(_err);
  674.     }
  675.     _res = Py_BuildValue("h",
  676.                          _rv);
  677.     return _res;
  678. }
  679.  
  680. static PyObject *Res_UseResFile(_self, _args)
  681.     PyObject *_self;
  682.     PyObject *_args;
  683. {
  684.     PyObject *_res = NULL;
  685.     short refNum;
  686.     if (!PyArg_ParseTuple(_args, "h",
  687.                           &refNum))
  688.         return NULL;
  689.     UseResFile(refNum);
  690.     {
  691.         OSErr _err = ResError();
  692.         if (_err != noErr) return PyMac_Error(_err);
  693.     }
  694.     Py_INCREF(Py_None);
  695.     _res = Py_None;
  696.     return _res;
  697. }
  698.  
  699. static PyObject *Res_CountTypes(_self, _args)
  700.     PyObject *_self;
  701.     PyObject *_args;
  702. {
  703.     PyObject *_res = NULL;
  704.     short _rv;
  705.     if (!PyArg_ParseTuple(_args, ""))
  706.         return NULL;
  707.     _rv = CountTypes();
  708.     {
  709.         OSErr _err = ResError();
  710.         if (_err != noErr) return PyMac_Error(_err);
  711.     }
  712.     _res = Py_BuildValue("h",
  713.                          _rv);
  714.     return _res;
  715. }
  716.  
  717. static PyObject *Res_Count1Types(_self, _args)
  718.     PyObject *_self;
  719.     PyObject *_args;
  720. {
  721.     PyObject *_res = NULL;
  722.     short _rv;
  723.     if (!PyArg_ParseTuple(_args, ""))
  724.         return NULL;
  725.     _rv = Count1Types();
  726.     {
  727.         OSErr _err = ResError();
  728.         if (_err != noErr) return PyMac_Error(_err);
  729.     }
  730.     _res = Py_BuildValue("h",
  731.                          _rv);
  732.     return _res;
  733. }
  734.  
  735. static PyObject *Res_GetIndType(_self, _args)
  736.     PyObject *_self;
  737.     PyObject *_args;
  738. {
  739.     PyObject *_res = NULL;
  740.     ResType theType;
  741.     short index;
  742.     if (!PyArg_ParseTuple(_args, "h",
  743.                           &index))
  744.         return NULL;
  745.     GetIndType(&theType,
  746.                index);
  747.     {
  748.         OSErr _err = ResError();
  749.         if (_err != noErr) return PyMac_Error(_err);
  750.     }
  751.     _res = Py_BuildValue("O&",
  752.                          PyMac_BuildOSType, theType);
  753.     return _res;
  754. }
  755.  
  756. static PyObject *Res_Get1IndType(_self, _args)
  757.     PyObject *_self;
  758.     PyObject *_args;
  759. {
  760.     PyObject *_res = NULL;
  761.     ResType theType;
  762.     short index;
  763.     if (!PyArg_ParseTuple(_args, "h",
  764.                           &index))
  765.         return NULL;
  766.     Get1IndType(&theType,
  767.                 index);
  768.     {
  769.         OSErr _err = ResError();
  770.         if (_err != noErr) return PyMac_Error(_err);
  771.     }
  772.     _res = Py_BuildValue("O&",
  773.                          PyMac_BuildOSType, theType);
  774.     return _res;
  775. }
  776.  
  777. static PyObject *Res_SetResLoad(_self, _args)
  778.     PyObject *_self;
  779.     PyObject *_args;
  780. {
  781.     PyObject *_res = NULL;
  782.     Boolean load;
  783.     if (!PyArg_ParseTuple(_args, "b",
  784.                           &load))
  785.         return NULL;
  786.     SetResLoad(load);
  787.     {
  788.         OSErr _err = ResError();
  789.         if (_err != noErr) return PyMac_Error(_err);
  790.     }
  791.     Py_INCREF(Py_None);
  792.     _res = Py_None;
  793.     return _res;
  794. }
  795.  
  796. static PyObject *Res_CountResources(_self, _args)
  797.     PyObject *_self;
  798.     PyObject *_args;
  799. {
  800.     PyObject *_res = NULL;
  801.     short _rv;
  802.     ResType theType;
  803.     if (!PyArg_ParseTuple(_args, "O&",
  804.                           PyMac_GetOSType, &theType))
  805.         return NULL;
  806.     _rv = CountResources(theType);
  807.     {
  808.         OSErr _err = ResError();
  809.         if (_err != noErr) return PyMac_Error(_err);
  810.     }
  811.     _res = Py_BuildValue("h",
  812.                          _rv);
  813.     return _res;
  814. }
  815.  
  816. static PyObject *Res_Count1Resources(_self, _args)
  817.     PyObject *_self;
  818.     PyObject *_args;
  819. {
  820.     PyObject *_res = NULL;
  821.     short _rv;
  822.     ResType theType;
  823.     if (!PyArg_ParseTuple(_args, "O&",
  824.                           PyMac_GetOSType, &theType))
  825.         return NULL;
  826.     _rv = Count1Resources(theType);
  827.     {
  828.         OSErr _err = ResError();
  829.         if (_err != noErr) return PyMac_Error(_err);
  830.     }
  831.     _res = Py_BuildValue("h",
  832.                          _rv);
  833.     return _res;
  834. }
  835.  
  836. static PyObject *Res_GetIndResource(_self, _args)
  837.     PyObject *_self;
  838.     PyObject *_args;
  839. {
  840.     PyObject *_res = NULL;
  841.     Handle _rv;
  842.     ResType theType;
  843.     short index;
  844.     if (!PyArg_ParseTuple(_args, "O&h",
  845.                           PyMac_GetOSType, &theType,
  846.                           &index))
  847.         return NULL;
  848.     _rv = GetIndResource(theType,
  849.                          index);
  850.     {
  851.         OSErr _err = ResError();
  852.         if (_err != noErr) return PyMac_Error(_err);
  853.     }
  854.     _res = Py_BuildValue("O&",
  855.                          ResObj_New, _rv);
  856.     return _res;
  857. }
  858.  
  859. static PyObject *Res_Get1IndResource(_self, _args)
  860.     PyObject *_self;
  861.     PyObject *_args;
  862. {
  863.     PyObject *_res = NULL;
  864.     Handle _rv;
  865.     ResType theType;
  866.     short index;
  867.     if (!PyArg_ParseTuple(_args, "O&h",
  868.                           PyMac_GetOSType, &theType,
  869.                           &index))
  870.         return NULL;
  871.     _rv = Get1IndResource(theType,
  872.                           index);
  873.     {
  874.         OSErr _err = ResError();
  875.         if (_err != noErr) return PyMac_Error(_err);
  876.     }
  877.     _res = Py_BuildValue("O&",
  878.                          ResObj_New, _rv);
  879.     return _res;
  880. }
  881.  
  882. static PyObject *Res_GetResource(_self, _args)
  883.     PyObject *_self;
  884.     PyObject *_args;
  885. {
  886.     PyObject *_res = NULL;
  887.     Handle _rv;
  888.     ResType theType;
  889.     short theID;
  890.     if (!PyArg_ParseTuple(_args, "O&h",
  891.                           PyMac_GetOSType, &theType,
  892.                           &theID))
  893.         return NULL;
  894.     _rv = GetResource(theType,
  895.                       theID);
  896.     {
  897.         OSErr _err = ResError();
  898.         if (_err != noErr) return PyMac_Error(_err);
  899.     }
  900.     _res = Py_BuildValue("O&",
  901.                          ResObj_New, _rv);
  902.     return _res;
  903. }
  904.  
  905. static PyObject *Res_Get1Resource(_self, _args)
  906.     PyObject *_self;
  907.     PyObject *_args;
  908. {
  909.     PyObject *_res = NULL;
  910.     Handle _rv;
  911.     ResType theType;
  912.     short theID;
  913.     if (!PyArg_ParseTuple(_args, "O&h",
  914.                           PyMac_GetOSType, &theType,
  915.                           &theID))
  916.         return NULL;
  917.     _rv = Get1Resource(theType,
  918.                        theID);
  919.     {
  920.         OSErr _err = ResError();
  921.         if (_err != noErr) return PyMac_Error(_err);
  922.     }
  923.     _res = Py_BuildValue("O&",
  924.                          ResObj_New, _rv);
  925.     return _res;
  926. }
  927.  
  928. static PyObject *Res_GetNamedResource(_self, _args)
  929.     PyObject *_self;
  930.     PyObject *_args;
  931. {
  932.     PyObject *_res = NULL;
  933.     Handle _rv;
  934.     ResType theType;
  935.     Str255 name;
  936.     if (!PyArg_ParseTuple(_args, "O&O&",
  937.                           PyMac_GetOSType, &theType,
  938.                           PyMac_GetStr255, name))
  939.         return NULL;
  940.     _rv = GetNamedResource(theType,
  941.                            name);
  942.     {
  943.         OSErr _err = ResError();
  944.         if (_err != noErr) return PyMac_Error(_err);
  945.     }
  946.     _res = Py_BuildValue("O&",
  947.                          ResObj_New, _rv);
  948.     return _res;
  949. }
  950.  
  951. static PyObject *Res_Get1NamedResource(_self, _args)
  952.     PyObject *_self;
  953.     PyObject *_args;
  954. {
  955.     PyObject *_res = NULL;
  956.     Handle _rv;
  957.     ResType theType;
  958.     Str255 name;
  959.     if (!PyArg_ParseTuple(_args, "O&O&",
  960.                           PyMac_GetOSType, &theType,
  961.                           PyMac_GetStr255, name))
  962.         return NULL;
  963.     _rv = Get1NamedResource(theType,
  964.                             name);
  965.     {
  966.         OSErr _err = ResError();
  967.         if (_err != noErr) return PyMac_Error(_err);
  968.     }
  969.     _res = Py_BuildValue("O&",
  970.                          ResObj_New, _rv);
  971.     return _res;
  972. }
  973.  
  974. static PyObject *Res_UniqueID(_self, _args)
  975.     PyObject *_self;
  976.     PyObject *_args;
  977. {
  978.     PyObject *_res = NULL;
  979.     short _rv;
  980.     ResType theType;
  981.     if (!PyArg_ParseTuple(_args, "O&",
  982.                           PyMac_GetOSType, &theType))
  983.         return NULL;
  984.     _rv = UniqueID(theType);
  985.     {
  986.         OSErr _err = ResError();
  987.         if (_err != noErr) return PyMac_Error(_err);
  988.     }
  989.     _res = Py_BuildValue("h",
  990.                          _rv);
  991.     return _res;
  992. }
  993.  
  994. static PyObject *Res_Unique1ID(_self, _args)
  995.     PyObject *_self;
  996.     PyObject *_args;
  997. {
  998.     PyObject *_res = NULL;
  999.     short _rv;
  1000.     ResType theType;
  1001.     if (!PyArg_ParseTuple(_args, "O&",
  1002.                           PyMac_GetOSType, &theType))
  1003.         return NULL;
  1004.     _rv = Unique1ID(theType);
  1005.     {
  1006.         OSErr _err = ResError();
  1007.         if (_err != noErr) return PyMac_Error(_err);
  1008.     }
  1009.     _res = Py_BuildValue("h",
  1010.                          _rv);
  1011.     return _res;
  1012. }
  1013.  
  1014. static PyObject *Res_UpdateResFile(_self, _args)
  1015.     PyObject *_self;
  1016.     PyObject *_args;
  1017. {
  1018.     PyObject *_res = NULL;
  1019.     short refNum;
  1020.     if (!PyArg_ParseTuple(_args, "h",
  1021.                           &refNum))
  1022.         return NULL;
  1023.     UpdateResFile(refNum);
  1024.     {
  1025.         OSErr _err = ResError();
  1026.         if (_err != noErr) return PyMac_Error(_err);
  1027.     }
  1028.     Py_INCREF(Py_None);
  1029.     _res = Py_None;
  1030.     return _res;
  1031. }
  1032.  
  1033. static PyObject *Res_SetResPurge(_self, _args)
  1034.     PyObject *_self;
  1035.     PyObject *_args;
  1036. {
  1037.     PyObject *_res = NULL;
  1038.     Boolean install;
  1039.     if (!PyArg_ParseTuple(_args, "b",
  1040.                           &install))
  1041.         return NULL;
  1042.     SetResPurge(install);
  1043.     {
  1044.         OSErr _err = ResError();
  1045.         if (_err != noErr) return PyMac_Error(_err);
  1046.     }
  1047.     Py_INCREF(Py_None);
  1048.     _res = Py_None;
  1049.     return _res;
  1050. }
  1051.  
  1052. static PyObject *Res_GetResFileAttrs(_self, _args)
  1053.     PyObject *_self;
  1054.     PyObject *_args;
  1055. {
  1056.     PyObject *_res = NULL;
  1057.     short _rv;
  1058.     short refNum;
  1059.     if (!PyArg_ParseTuple(_args, "h",
  1060.                           &refNum))
  1061.         return NULL;
  1062.     _rv = GetResFileAttrs(refNum);
  1063.     {
  1064.         OSErr _err = ResError();
  1065.         if (_err != noErr) return PyMac_Error(_err);
  1066.     }
  1067.     _res = Py_BuildValue("h",
  1068.                          _rv);
  1069.     return _res;
  1070. }
  1071.  
  1072. static PyObject *Res_SetResFileAttrs(_self, _args)
  1073.     PyObject *_self;
  1074.     PyObject *_args;
  1075. {
  1076.     PyObject *_res = NULL;
  1077.     short refNum;
  1078.     short attrs;
  1079.     if (!PyArg_ParseTuple(_args, "hh",
  1080.                           &refNum,
  1081.                           &attrs))
  1082.         return NULL;
  1083.     SetResFileAttrs(refNum,
  1084.                     attrs);
  1085.     {
  1086.         OSErr _err = ResError();
  1087.         if (_err != noErr) return PyMac_Error(_err);
  1088.     }
  1089.     Py_INCREF(Py_None);
  1090.     _res = Py_None;
  1091.     return _res;
  1092. }
  1093.  
  1094. static PyObject *Res_OpenRFPerm(_self, _args)
  1095.     PyObject *_self;
  1096.     PyObject *_args;
  1097. {
  1098.     PyObject *_res = NULL;
  1099.     short _rv;
  1100.     Str255 fileName;
  1101.     short vRefNum;
  1102.     SignedByte permission;
  1103.     if (!PyArg_ParseTuple(_args, "O&hb",
  1104.                           PyMac_GetStr255, fileName,
  1105.                           &vRefNum,
  1106.                           &permission))
  1107.         return NULL;
  1108.     _rv = OpenRFPerm(fileName,
  1109.                      vRefNum,
  1110.                      permission);
  1111.     {
  1112.         OSErr _err = ResError();
  1113.         if (_err != noErr) return PyMac_Error(_err);
  1114.     }
  1115.     _res = Py_BuildValue("h",
  1116.                          _rv);
  1117.     return _res;
  1118. }
  1119.  
  1120. static PyObject *Res_RGetResource(_self, _args)
  1121.     PyObject *_self;
  1122.     PyObject *_args;
  1123. {
  1124.     PyObject *_res = NULL;
  1125.     Handle _rv;
  1126.     ResType theType;
  1127.     short theID;
  1128.     if (!PyArg_ParseTuple(_args, "O&h",
  1129.                           PyMac_GetOSType, &theType,
  1130.                           &theID))
  1131.         return NULL;
  1132.     _rv = RGetResource(theType,
  1133.                        theID);
  1134.     {
  1135.         OSErr _err = ResError();
  1136.         if (_err != noErr) return PyMac_Error(_err);
  1137.     }
  1138.     _res = Py_BuildValue("O&",
  1139.                          ResObj_New, _rv);
  1140.     return _res;
  1141. }
  1142.  
  1143. static PyObject *Res_HOpenResFile(_self, _args)
  1144.     PyObject *_self;
  1145.     PyObject *_args;
  1146. {
  1147.     PyObject *_res = NULL;
  1148.     short _rv;
  1149.     short vRefNum;
  1150.     long dirID;
  1151.     Str255 fileName;
  1152.     SignedByte permission;
  1153.     if (!PyArg_ParseTuple(_args, "hlO&b",
  1154.                           &vRefNum,
  1155.                           &dirID,
  1156.                           PyMac_GetStr255, fileName,
  1157.                           &permission))
  1158.         return NULL;
  1159.     _rv = HOpenResFile(vRefNum,
  1160.                        dirID,
  1161.                        fileName,
  1162.                        permission);
  1163.     {
  1164.         OSErr _err = ResError();
  1165.         if (_err != noErr) return PyMac_Error(_err);
  1166.     }
  1167.     _res = Py_BuildValue("h",
  1168.                          _rv);
  1169.     return _res;
  1170. }
  1171.  
  1172. static PyObject *Res_HCreateResFile(_self, _args)
  1173.     PyObject *_self;
  1174.     PyObject *_args;
  1175. {
  1176.     PyObject *_res = NULL;
  1177.     short vRefNum;
  1178.     long dirID;
  1179.     Str255 fileName;
  1180.     if (!PyArg_ParseTuple(_args, "hlO&",
  1181.                           &vRefNum,
  1182.                           &dirID,
  1183.                           PyMac_GetStr255, fileName))
  1184.         return NULL;
  1185.     HCreateResFile(vRefNum,
  1186.                    dirID,
  1187.                    fileName);
  1188.     {
  1189.         OSErr _err = ResError();
  1190.         if (_err != noErr) return PyMac_Error(_err);
  1191.     }
  1192.     Py_INCREF(Py_None);
  1193.     _res = Py_None;
  1194.     return _res;
  1195. }
  1196.  
  1197. static PyObject *Res_FSpOpenResFile(_self, _args)
  1198.     PyObject *_self;
  1199.     PyObject *_args;
  1200. {
  1201.     PyObject *_res = NULL;
  1202.     short _rv;
  1203.     FSSpec spec;
  1204.     SignedByte permission;
  1205.     if (!PyArg_ParseTuple(_args, "O&b",
  1206.                           PyMac_GetFSSpec, &spec,
  1207.                           &permission))
  1208.         return NULL;
  1209.     _rv = FSpOpenResFile(&spec,
  1210.                          permission);
  1211.     {
  1212.         OSErr _err = ResError();
  1213.         if (_err != noErr) return PyMac_Error(_err);
  1214.     }
  1215.     _res = Py_BuildValue("h",
  1216.                          _rv);
  1217.     return _res;
  1218. }
  1219.  
  1220. static PyObject *Res_FSpCreateResFile(_self, _args)
  1221.     PyObject *_self;
  1222.     PyObject *_args;
  1223. {
  1224.     PyObject *_res = NULL;
  1225.     FSSpec spec;
  1226.     OSType creator;
  1227.     OSType fileType;
  1228.     ScriptCode scriptTag;
  1229.     if (!PyArg_ParseTuple(_args, "O&O&O&h",
  1230.                           PyMac_GetFSSpec, &spec,
  1231.                           PyMac_GetOSType, &creator,
  1232.                           PyMac_GetOSType, &fileType,
  1233.                           &scriptTag))
  1234.         return NULL;
  1235.     FSpCreateResFile(&spec,
  1236.                      creator,
  1237.                      fileType,
  1238.                      scriptTag);
  1239.     {
  1240.         OSErr _err = ResError();
  1241.         if (_err != noErr) return PyMac_Error(_err);
  1242.     }
  1243.     Py_INCREF(Py_None);
  1244.     _res = Py_None;
  1245.     return _res;
  1246. }
  1247.  
  1248. static PyObject *Res_Resource(_self, _args)
  1249.     PyObject *_self;
  1250.     PyObject *_args;
  1251. {
  1252.     PyObject *_res = NULL;
  1253.  
  1254.     char *buf;
  1255.     int len;
  1256.     Handle h;
  1257.  
  1258.     if (!PyArg_ParseTuple(_args, "s#", &buf, &len))
  1259.         return NULL;
  1260.     h = NewHandle(len);
  1261.     if ( h == NULL ) {
  1262.         PyErr_NoMemory();
  1263.         return NULL;
  1264.     }
  1265.     HLock(h);
  1266.     memcpy(*h, buf, len);
  1267.     HUnlock(h);
  1268.     return (PyObject *)ResObj_New(h);
  1269.  
  1270. }
  1271.  
  1272. static PyMethodDef Res_methods[] = {
  1273.     {"InitResources", (PyCFunction)Res_InitResources, 1,
  1274.      "() -> (short _rv)"},
  1275.     {"RsrcZoneInit", (PyCFunction)Res_RsrcZoneInit, 1,
  1276.      "() -> None"},
  1277.     {"CloseResFile", (PyCFunction)Res_CloseResFile, 1,
  1278.      "(short refNum) -> None"},
  1279.     {"ResError", (PyCFunction)Res_ResError, 1,
  1280.      "() -> (short _rv)"},
  1281.     {"CurResFile", (PyCFunction)Res_CurResFile, 1,
  1282.      "() -> (short _rv)"},
  1283.     {"CreateResFile", (PyCFunction)Res_CreateResFile, 1,
  1284.      "(Str255 fileName) -> None"},
  1285.     {"OpenResFile", (PyCFunction)Res_OpenResFile, 1,
  1286.      "(Str255 fileName) -> (short _rv)"},
  1287.     {"UseResFile", (PyCFunction)Res_UseResFile, 1,
  1288.      "(short refNum) -> None"},
  1289.     {"CountTypes", (PyCFunction)Res_CountTypes, 1,
  1290.      "() -> (short _rv)"},
  1291.     {"Count1Types", (PyCFunction)Res_Count1Types, 1,
  1292.      "() -> (short _rv)"},
  1293.     {"GetIndType", (PyCFunction)Res_GetIndType, 1,
  1294.      "(short index) -> (ResType theType)"},
  1295.     {"Get1IndType", (PyCFunction)Res_Get1IndType, 1,
  1296.      "(short index) -> (ResType theType)"},
  1297.     {"SetResLoad", (PyCFunction)Res_SetResLoad, 1,
  1298.      "(Boolean load) -> None"},
  1299.     {"CountResources", (PyCFunction)Res_CountResources, 1,
  1300.      "(ResType theType) -> (short _rv)"},
  1301.     {"Count1Resources", (PyCFunction)Res_Count1Resources, 1,
  1302.      "(ResType theType) -> (short _rv)"},
  1303.     {"GetIndResource", (PyCFunction)Res_GetIndResource, 1,
  1304.      "(ResType theType, short index) -> (Handle _rv)"},
  1305.     {"Get1IndResource", (PyCFunction)Res_Get1IndResource, 1,
  1306.      "(ResType theType, short index) -> (Handle _rv)"},
  1307.     {"GetResource", (PyCFunction)Res_GetResource, 1,
  1308.      "(ResType theType, short theID) -> (Handle _rv)"},
  1309.     {"Get1Resource", (PyCFunction)Res_Get1Resource, 1,
  1310.      "(ResType theType, short theID) -> (Handle _rv)"},
  1311.     {"GetNamedResource", (PyCFunction)Res_GetNamedResource, 1,
  1312.      "(ResType theType, Str255 name) -> (Handle _rv)"},
  1313.     {"Get1NamedResource", (PyCFunction)Res_Get1NamedResource, 1,
  1314.      "(ResType theType, Str255 name) -> (Handle _rv)"},
  1315.     {"UniqueID", (PyCFunction)Res_UniqueID, 1,
  1316.      "(ResType theType) -> (short _rv)"},
  1317.     {"Unique1ID", (PyCFunction)Res_Unique1ID, 1,
  1318.      "(ResType theType) -> (short _rv)"},
  1319.     {"UpdateResFile", (PyCFunction)Res_UpdateResFile, 1,
  1320.      "(short refNum) -> None"},
  1321.     {"SetResPurge", (PyCFunction)Res_SetResPurge, 1,
  1322.      "(Boolean install) -> None"},
  1323.     {"GetResFileAttrs", (PyCFunction)Res_GetResFileAttrs, 1,
  1324.      "(short refNum) -> (short _rv)"},
  1325.     {"SetResFileAttrs", (PyCFunction)Res_SetResFileAttrs, 1,
  1326.      "(short refNum, short attrs) -> None"},
  1327.     {"OpenRFPerm", (PyCFunction)Res_OpenRFPerm, 1,
  1328.      "(Str255 fileName, short vRefNum, SignedByte permission) -> (short _rv)"},
  1329.     {"RGetResource", (PyCFunction)Res_RGetResource, 1,
  1330.      "(ResType theType, short theID) -> (Handle _rv)"},
  1331.     {"HOpenResFile", (PyCFunction)Res_HOpenResFile, 1,
  1332.      "(short vRefNum, long dirID, Str255 fileName, SignedByte permission) -> (short _rv)"},
  1333.     {"HCreateResFile", (PyCFunction)Res_HCreateResFile, 1,
  1334.      "(short vRefNum, long dirID, Str255 fileName) -> None"},
  1335.     {"FSpOpenResFile", (PyCFunction)Res_FSpOpenResFile, 1,
  1336.      "(FSSpec spec, SignedByte permission) -> (short _rv)"},
  1337.     {"FSpCreateResFile", (PyCFunction)Res_FSpCreateResFile, 1,
  1338.      "(FSSpec spec, OSType creator, OSType fileType, ScriptCode scriptTag) -> None"},
  1339.     {"Resource", (PyCFunction)Res_Resource, 1,
  1340.      "Convert a string to a resource object.\n\nThe created resource object is actually just a handle.\nApply AddResource() to write it to a resource file.\n"},
  1341.     {NULL, NULL, 0}
  1342. };
  1343.  
  1344.  
  1345.  
  1346.  
  1347. /* Alternative version of ResObj_New, which returns None for null argument */
  1348. PyObject *OptResObj_New(itself)
  1349.     Handle itself;
  1350. {
  1351.     ResourceObject *it;
  1352.     if (itself == NULL) {
  1353.         Py_INCREF(Py_None);
  1354.         return Py_None;
  1355.     }
  1356.     return ResObj_New(itself);
  1357. }
  1358.  
  1359. OptResObj_Convert(v, p_itself)
  1360.     PyObject *v;
  1361.     Handle *p_itself;
  1362. {
  1363.     if ( v == Py_None ) {
  1364.         *p_itself = NULL;
  1365.         return 1;
  1366.     }
  1367.     if (!ResObj_Check(v))
  1368.     {
  1369.         PyErr_SetString(PyExc_TypeError, "Resource required");
  1370.         return 0;
  1371.     }
  1372.     *p_itself = ((ResourceObject *)v)->ob_itself;
  1373.     return 1;
  1374. }
  1375.  
  1376.  
  1377.  
  1378. void initRes()
  1379. {
  1380.     PyObject *m;
  1381.     PyObject *d;
  1382.  
  1383.  
  1384.  
  1385.  
  1386.  
  1387.     m = Py_InitModule("Res", Res_methods);
  1388.     d = PyModule_GetDict(m);
  1389.     Res_Error = PyMac_GetOSErrException();
  1390.     if (Res_Error == NULL ||
  1391.         PyDict_SetItemString(d, "Error", Res_Error) != 0)
  1392.         Py_FatalError("can't initialize Res.Error");
  1393. }
  1394.  
  1395. /* ========================= End module Res ========================= */
  1396.  
  1397.